﻿// -----------------------------------------------------------------------
// <copyright file="VampiroFormModel.cs" company="Storytelling">
// TODO: Update copyright text.
// </copyright>
// -----------------------------------------------------------------------
namespace Storytelling.Modelos.VTR
{
    using Storytelling.Entidades.VTR;
    using System.ComponentModel.DataAnnotations;
    using Storytelling.Utils;
    using System.Linq;
    using System.Collections.Generic;
    using Storytelling.Entidades;

    public class VampiroFormModel : EntidadeFormModel<Vampiro>, IEvolucaoFormModel  
    {
        private static IDictionary<TipoCampo, string> evolucaoOpcoes;

        private string cla;
        private string coalizao;
        private long[] vampiroDisciplinaAgrupamento;
        private string[] vampiroDisciplinaDisciplina;
        private string[] vampiroDevocaoDevocao;
        private string[] vampiroRitualRitual;

        static VampiroFormModel()
        {
            evolucaoOpcoes = new Dictionary<TipoCampo, string>();
            evolucaoOpcoes.Add(TipoCampo.Devocao, "Devoção");
            evolucaoOpcoes.Add(TipoCampo.Disciplina, "Disciplina");
            evolucaoOpcoes.Add(TipoCampo.Ritual, "Ritual");
        }

        public override long? Id
        {
            get { return base.Id; }
            set { base.Id = value; }
        }

        [Display(Name = "Atributos Preferenciais")]
        public virtual bool AtributosPreferenciais
        {
            get { return Entidade.Preferencial; }
            set { Entidade.Preferencial = value; }
        }

        [Display(Name = "Penalidade em Força de Vontade")]
        public virtual int PenalidadeVontade
        {
            get { return Entidade.PenalidadeVontade; }
            set { Entidade.PenalidadeVontade = value; }
        }

        public virtual string OpcaoUm 
        {
            get
            {
                if (Entidade.Cla != null)
                {
                    switch (Entidade.Cla.Heranca.Value)
	                {
		                case Heranca.Devas:
                            return "Destreza";
                        case Heranca.Gangrel:
                            return "Autocontrole";
                        case Heranca.Mekhet:
                            return "Inteligência";
                        case Heranca.Nosferatu:
                            return "Autocontrole";
                        case Heranca.Ventrue:
                            return "Presença";
                        default :
                            return null;
	                }
                }
                else
                {
                    return "----------";
                }
            }
        }

        public virtual string OpcaoDois
        {
            get
            {
                if (Entidade.Cla != null)
                {
                    switch (Entidade.Cla.Heranca.Value)
                    {
                        case Heranca.Devas:
                            return "Manipulação";
                        case Heranca.Gangrel:
                            return "Vigor";
                        case Heranca.Mekhet:
                            return "Raciocínio";
                        case Heranca.Nosferatu:
                            return "Força";
                        case Heranca.Ventrue:
                            return "Perseverança";
                        default:
                            return null;
                    }
                }
                else
                {
                    return "----------";
                }
            }
        }

        public virtual string Cla
        {
            get
            {
                if (Entidade.Cla != null && !string.IsNullOrEmpty(Entidade.Cla.Nome))
                {
                    cla = Entidade.Cla.Nome;
                }
                else
                {
                    cla = "";
                }
                return cla;
            }
            set { cla = value; }
        }

        [Required]
        [Display(Name = "Clã")]
        public virtual long ClaValor
        {
            get { return Entidade.ClaId; }
            set { Entidade.ClaId = value; }
        }

        public virtual string Coalizao
        {
            get
            {
                if (Entidade.Coalizao != null && !string.IsNullOrEmpty(Entidade.Coalizao.Nome))
                {
                    coalizao = Entidade.Coalizao.Nome;
                }
                else if (coalizao == null)
                {
                    coalizao = "";
                }
                return coalizao;
            }
            set { coalizao = value; }
        }

        [Display(Name = "Coalizão")]
        public virtual long CoalizaoValor
        {
            get { return Entidade.CoalizaoId.HasValue ? Entidade.CoalizaoId.Value : 0; }
            set { Entidade.CoalizaoId = value > 0 ? (long?)value : null; }
        }

        [Range(1, 10, ErrorMessage = "A Moralidade deve ser de 1 a 10")]
        [Display(Name = "Potência de Sangue")]
        public virtual int PotenciaSangue
        {
            get { return Entidade.Fator; }
            set { Entidade.Fator = value; }
        }

        [Display(Name = "Pontos de Sangue")]
        public virtual int Energia
        {
            get { return Entidade.Energia; }
        }

        public virtual int LimiteEnergia
        {
            get 
            {
                int limite = 10;

                switch (Entidade.Fator)
                {
                    case 2:
                        limite = 11;
                        break;
                    case 3:
                        limite = 12;
                        break;
                    case 4:
                        limite = 13;
                        break;
                    case 5:
                        limite = 14;
                        break;
                    case 6:
                        limite = 15;
                        break;
                    case 7:
                        limite = 20;
                        break;
                    case 8:
                        limite = 30;
                        break;
                    case 9:
                        limite = 50;
                        break;
                    case 10:
                        limite = 100;
                        break;
                }

                return limite; 
            }
        }

        public virtual int Experiencia
        {
            get { return Entidade.Experiencia; }
        }

        public virtual IDictionary<TipoCampo, string> Opcoes
        {
            get { return evolucaoOpcoes; }
        }

        public virtual string ConfigurarAutocompleteEvolucao
        {
            get { return "configurarAutocompleteEvolucaoVampiro"; }
        }

        #region Disciplinas

        public virtual long[] VampiroDisciplinaId
        {
            get
            {
                return Entidade.Disciplinas != null ? Entidade.Disciplinas.Select(ent => ent.Id).ToArray() : new long[0];
            }
            set
            {
                Entidade.Transferidor<Vampiro, VampiroDisciplina, long>(value, ent => ent.Disciplinas, (valor, item) =>
                {
                    item.VampiroId = Entidade.Id;
                    item.Id = valor;
                });
            }
        }

        public virtual string[] VampiroDisciplinaDisciplina
        {
            get
            {
                Entidade.CarregarArray<Vampiro, VampiroDisciplina>(ref vampiroDisciplinaDisciplina, ent => ent.Disciplinas, item => item.Disciplina);
                return vampiroDisciplinaDisciplina;
            }
            set { vampiroDisciplinaDisciplina = value; }
        }

        public virtual long[] VampiroDisciplinaAgrupamento
        {
            get
            {
                if (vampiroDisciplinaAgrupamento == null)
                {
                    vampiroDisciplinaAgrupamento = Entidade.Disciplinas != null ? Entidade.Disciplinas
                        .Select(ent => ent.Disciplina != null && ent.Disciplina.AgrupamentoId.HasValue ? ent.Disciplina.AgrupamentoId.Value : 0).ToArray() : new long[0];
                }

                return vampiroDisciplinaAgrupamento;
            }
            set { vampiroDisciplinaAgrupamento = value; }
        }

        [ArrayRange(1, default(long))]
        [Display(Name = "Disciplina")]
        public virtual long[] VampiroDisciplinaDisciplinaValor
        {
            get
            {
                return Entidade.Disciplinas != null ? Entidade.Disciplinas.Select(ent => ent.DisciplinaId).ToArray() : new long[0];
            }
            set
            {
                Entidade.Transferidor<Vampiro, VampiroDisciplina, long>(value, ent => ent.Disciplinas, (valor, item) =>
                {
                    item.VampiroId = Entidade.Id;
                    item.DisciplinaId = valor;
                });
            }
        }

        [ArrayRange(0, default(int))]
        [Display(Name = "Nível")]
        public virtual int[] VampiroDisciplinaNiveis
        {
            get
            {
                return Entidade.Disciplinas != null ? Entidade.Disciplinas.Select(ent => ent.Nivel).ToArray() : new int[0];
            }
            set
            {
                Entidade.Transferidor<Vampiro, VampiroDisciplina, int>(value, ent => ent.Disciplinas, (valor, item) =>
                {
                    item.VampiroId = Entidade.Id;
                    item.Nivel = valor;
                });
            }
        } 

        #endregion

        #region Devoções

        public virtual long[] VampiroDevocaoId
        {
            get
            {
                return Entidade.Devocoes != null ? Entidade.Devocoes.Select(ent => ent.Id).ToArray() : new long[0];
            }
            set
            {
                Entidade.Transferidor<Vampiro, VampiroDevocao, long>(value, ent => ent.Devocoes, (valor, item) =>
                {
                    item.VampiroId = Entidade.Id;
                    item.Id = valor;
                });
            }
        }

        public virtual string[] VampiroDevocaoDevocao
        {
            get
            {
                Entidade.CarregarArray<Vampiro, VampiroDevocao>(ref vampiroDevocaoDevocao, ent => ent.Devocoes, item => item.Devocao);
                return vampiroDevocaoDevocao;
            }
            set { vampiroDevocaoDevocao = value; }
        }

        [Display(Name = "Devoção")]
        public virtual long[] VampiroDevocaoDevocaoValor
        {
            get
            {
                return Entidade.Devocoes != null ? Entidade.Devocoes.Select(ent => ent.DevocaoId).ToArray() : new long[0];
            }
            set
            {
                Entidade.Transferidor<Vampiro, VampiroDevocao, long>(value, ent => ent.Devocoes, (valor, item) =>
                {
                    item.VampiroId = Entidade.Id;
                    item.DevocaoId = valor;
                });
            }
        }

        #endregion

        #region Rituais

        public virtual long[] VampiroRitualId
        {
            get
            {
                return Entidade.Rituais != null ? Entidade.Rituais.Select(ent => ent.Id).ToArray() : new long[0];
            }
            set
            {
                Entidade.Transferidor<Vampiro, VampiroRitual, long>(value, ent => ent.Rituais, (valor, item) =>
                {
                    item.VampiroId = Entidade.Id;
                    item.Id = valor;
                });
            }
        }

        public virtual string[] VampiroRitualRitual
        {
            get
            {
                Entidade.CarregarArray<Vampiro, VampiroRitual>(ref vampiroRitualRitual, ent => ent.Rituais, item => item.Ritual);
                return vampiroRitualRitual;
            }
            set { vampiroRitualRitual = value; }
        }

        [Display(Name = "Ritual")]
        public virtual long[] VampiroRitualRitualValor
        {
            get
            {
                return Entidade.Rituais != null ? Entidade.Rituais.Select(ent => ent.RitualId).ToArray() : new long[0];
            }
            set
            {
                Entidade.Transferidor<Vampiro, VampiroRitual, long>(value, ent => ent.Rituais, (valor, item) =>
                {
                    item.VampiroId = Entidade.Id;
                    item.RitualId = valor;
                });
            }
        }

        #endregion
    }
}
